/*平衡树 tree+heap -> treap
* 1. BST(Binary search tree)
    (1)当前节点的左子树中的任意一个点的权值 < 当前节点的权值
    (2)当前节点的左子树中的任意一个点的权值 > 当前节点的权值

* 2.op
    (1)插入一个数
    (2)删除一个数
    (3)查询一个数的前驱（比它小的最大数）
        中序遍历中的前一个位置
        

    (4)查询一个数的后继（比它大的最小数）
        中序遍历中的后一个位置
        
    (5)查询最大/最小
        最大:
        1.存在左子树
            left = p->left;
            while(left -> left) left = left -> left;
        1.不存在左子树
            不在考虑向下执行
        最小:
        1.存在右子树
            right = p->right;
            while(right -> right) right = right -> right;
        1.不存在左子树
            不在考虑向下执行

    (5)查询某个值的排名
        
    (6)查询排名对应的值

    (7)比某个数小的最大值

    (8)比某个数大的最小值

    struct node{
        int l,r;        //左子树和右子树
        int key,val;    //BST权值 heap权重
        int cnt,size;   //该key的数目，以及以该点为根的子树的大小（所有cnt相加）
    }tree[N];

    key实现BST val实现heap
    先按照key确定值(插入，删除)的大致范围，再根据val维持树形，保证BST不会退化为链表
    
* 3. 旋转
    (1)左旋 zig
        inline void zig(int &u){    //右旋
            auto &U = tree[u], &L = tree[U.l], &R = tree[U.r];
            int ul = U.l;
            U.l = L.r;
            L.r = u;
            u = ul;                   //通过指针间接改变和原来的u关联的值
            push_up(U.r);
            push_up(u);              //push_up就是更新size
        }
    (2)右旋 zag
        inline void zag(int &p){    //左旋
            auto &U = tree[u], &L = tree[U.l], &R = tree[U.r];
            int ur = U.r;
            U.r = R.l;
            R. l= ur;
            u = ur;                   //通过指针间接改变和原来的u关联的值
            push_up(U.l);
            push_up(u);              //更新size
        }

* 本题:
    op1:插入一个数
    op2:找到大于等于某个数的最小数
    op3:找到小于等于某个数的最大数
*/

#define DEBUG
#pragma GCC optimize("O1,O2,O3,Ofast")
#pragma GCC optimize("no-stack-protector,unroll-loops,fast-math,inline")
#pragma GCC target("avx,avx2,fma")
#pragma GCC target("sse,sse2,sse3,sse4,sse4.1,sse4.2,ssse3")

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 33010, INF = 0x3f3f3f3f;

int n;

struct node{
    int l,r;        //左子树和右子树
    int key,val;    //权值 权重
}tree[N];

int root, idx; 

inline int get_node(int key) //建点
{
    tree[++idx].key = key;
    tree[idx].val = rand();
    return idx;
}

inline void zig(int &u){    //右旋
    auto &U = tree[u], &L = tree[U.l], &R = tree[U.r];
    int ul = U.l;
    U.l = L.r;
    L.r = u;
    u = ul;                   //通过指针间接改变和原来的u关联的值
}

inline void zag(int &u){    //左旋
    auto &U = tree[u], &L = tree[U.l], &R = tree[U.r];
    int ur = U.r;
    U.r = R.l;
    R.l= u;
    u = ur;                   //通过指针间接改变和原来的u关联的值
}

void build() //建树
{
    get_node(-INF), get_node(INF);
    root = 1; tree[1].r = 2;
    // push_up(root);
    if(tree[root].val < tree[2].val)
        zag(root);
}

void insert(int &u, int key)
{
    if(!u) u = get_node(key);    
    else if(tree[u].key > key)  { //在左子树中插入
        insert(tree[u].l, key);
        if(tree[tree[u].l].val > tree[u].val) zig(u);
    } 
    else { //在右子树中插入
        insert(tree[u].r, key);
        if(tree[tree[u].r].val > tree[u].val) zag(u);
    }
}

int get_prev(int &u,int key)
{
    if(!u) return -INF;
    auto &U = tree[u], &L = tree[U.l], &R = tree[U.r];
    if(U.key > key) return get_prev(U.l, key);
    return max(U.key, get_prev(U.r, key)); //包含当前key已存在
}

int get_next(int &u,int key)
{
    if(!u) return INF;
    auto &U = tree[u], &L = tree[U.l], &R = tree[U.r];
    if(U.key < key) return get_next(U.r, key);
    return min(U.key, get_next(U.l, key)); //包含当前key已存在
}

void Print()
{
    for(int i = 0; i <= idx; i++)
        printf("tree[%d]: val:%d, lid:%d rid:%d \n",i, tree[i].val, tree[i].l, tree[i].r);
}

int main()
{

    #ifdef DEBUG
    freopen("./in.txt","r",stdin);
    #else
    ios::sync_with_stdio(false);   
	cin.tie(0);
    #endif

    build();
    cin >> n;
    int sum = 0;
    for(int i = 1; i <= n; i++)
    {
        int x; cin >> x;
        
        if(i == 1) sum = x;
        else sum += min(x - get_prev(root, x), get_next(root, x) - x);
        //printf("day:%d sum:%d\n", i, sum);
        insert(root, x);
    }
    cout << sum << endl;
    return 0;
}
